package com.example.java.concurrent.lock;

import java.util.concurrent.locks.ReentrantLock;

// ReentrantLock 是一个可重入的锁，它允许线程在获取锁后多次进入，直到释放锁。
// 这意味着如果一个线程已经获取了锁，它可以再次获取锁而不会被阻塞。如果一个线程获取了锁，它可以再次获取同样的锁，避免了死锁问题。
public class ReentrantLockDemo {
    public static void main(String[] args) {
        Counter counter = new Counter();

        // 创建多个线程来增加计数
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        // 启动线程
        t1.start();
        t2.start();

        try {
            // 等待线程结束
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 输出最终计数
        System.out.println("Final count: " + counter.getCount());
    }


    static class Counter {
        private int count = 0;
        private final ReentrantLock lock = new ReentrantLock();

        // 增加计数的方法
        public void increment() {
            lock.lock(); // 获取锁
            try {
                count++;
            } finally {
                lock.unlock(); // 确保释放锁
            }
        }

        // 获取当前计数的方法
        public int getCount() {
            lock.lock();
            try {
                return count;
            } finally {
                lock.unlock();
            }
        }
    }
}
